package util.date;

import org.joda.time.DateTime;
import org.joda.time.LocalDate;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
import org.springframework.util.StringUtils;
import util.string.StringUtil;

import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;

/**
 * @Author zt
 * @date 2021/11/11 14:51
 * @Version 1.0
 */
public class DateUtil {


    /** yyyy:年 */
    public static final String DATE_YEAR = "yyyy";

    /** MM：月 */
    public static final String DATE_MONTH = "MM";

    /** DD：日 */
    public static final String DATE_DAY = "dd";

    /** HH：时 */
    public static final String DATE_HOUR = "HH";

    /** mm：分 */
    public static final String DATE_MINUTE = "mm";

    /** ss：秒 */
    public static final String DATE_SECONDES = "ss";

    /** yyyy-MM-dd */
    public static final String DATE_FORMAT1 = "yyyy-MM-dd";

    /** yyyy-MM-dd hh:mm:ss */
    public static final String DATE_FORMAT2 = "yyyy-MM-dd HH:mm:ss";

    /** yyyy-MM-dd hh:mm:ss|SSS */
    public static final String TIME_FORMAT_SSS = "yyyy-MM-dd HH:mm:ss|SSS";

    /** yyyyMMdd */
    public static final String DATE_NOFUll_FORMAT = "yyyyMMdd";

    /** yyyyMMddhhmmss */
    public static final String TIME_NOFUll_FORMAT = "yyyyMMddHHmmss";

    /**
     *
     * 格式转换<br>
     * yyyy-MM-dd hh:mm:ss 和 yyyyMMddhhmmss 相互转换<br>
     * yyyy-mm-dd 和yyyymmss 相互转换
     * @param value 日期
     * @return 结果
     */
    public static String formatString(String value) {
        String sReturn = "";
        if (value == null || "".equals(value))
            return sReturn;
        if (value.length() == 14) {   //长度为14格式转换成yyyy-mm-dd hh:mm:ss
            sReturn = value.substring(0, 4) + "-" + value.substring(4, 6) + "-" + value.substring(6, 8) + " "
                    + value.substring(8, 10) + ":" + value.substring(10, 12) + ":" + value.substring(12, 14);
            return sReturn;
        }
        if (value.length() == 19) {   //长度为19格式转换成yyyymmddhhmmss
            sReturn = value.substring(0, 4) + value.substring(5, 7) + value.substring(8, 10) + value.substring(11, 13)
                    + value.substring(14, 16) + value.substring(17, 19);
            return sReturn;
        }
        if(value.length() == 10){     //长度为10格式转换成yyyymmhh
            sReturn = value.substring(0, 4) + value.substring(5,7) + value.substring(8,10);
        }
        if(value.length() == 8){      //长度为8格式转化成yyyy-mm-dd
            sReturn = value.substring(0, 4) + "-" + value.substring(4, 6) + "-" + value.substring(6, 8);
        }
        return sReturn;
    }

    /**
     * date 转 String
     * @param date 数据源
     * @param format 格式
     * @return 结果
     */
    public static String formatDate(String date, String format) {
        if (date == null || "".equals(date)){
            return "";
        }
        Date dt = null;
        SimpleDateFormat inFmt = null;
        SimpleDateFormat outFmt = null;
        ParsePosition pos = new ParsePosition(0);
        date = date.replace("-", "").replace(":", "");
        if ((date == null) || ("".equals(date.trim())))
            return "";
        try {
            if (Long.parseLong(date) == 0L)
                return "";
        } catch (Exception nume) {
            return date;
        }
        try {
            switch (date.trim().length()) {
                case 14:
                    inFmt = new SimpleDateFormat("yyyyMMddHHmmss");
                    break;
                case 12:
                    inFmt = new SimpleDateFormat("yyyyMMddHHmm");
                    break;
                case 10:
                    inFmt = new SimpleDateFormat("yyyyMMddHH");
                    break;
                case 8:
                    inFmt = new SimpleDateFormat("yyyyMMdd");
                    break;
                case 6:
                    inFmt = new SimpleDateFormat("yyyyMM");
                    break;
                case 7:
                case 9:
                case 11:
                case 13:
                default:
                    return date;
            }
            if ((dt = inFmt.parse(date, pos)) == null)
                return date;
            if ((format == null) || ("".equals(format.trim()))) {
                outFmt = new SimpleDateFormat("yyyy年MM月dd日");
            } else {
                outFmt = new SimpleDateFormat(format);
            }
            return outFmt.format(dt);
        } catch (Exception ex) {
        }
        return date;
    }

    /**
     * 格式化日期
     * @param date 数据源
     * @param format 格式
     * @return 结果
     */
    public static String formatDate(Date date,String format){
        return formatDate(DateUtil.formatDate(date), format);
    }

    /**
     * 格式化是时间，采用默认格式（yyyy-MM-dd HH:mm:ss）
     * @param value 数据源
     * @return 结果
     */
    public static String formatDate(String value){
        return getFormat(DATE_FORMAT2).format(DateUtil.formatDate(value, DATE_FORMAT2));
    }

    /**
     * 格式化日期
     * @param value 数据源
     * @return 结果
     */
    public static String formatDate(Date value){
        return formatDate(DateUtil.formatDate(value));
    }

    /**
     * 获取日期显示格式，为空默认为yyyy-mm-dd HH:mm:ss
     * @param format 格式
     * @return 结果
     */
    protected static SimpleDateFormat getFormat(String format){
        if(format == null || "".equals(format)){
            format = DATE_FORMAT2;
        }
        return new SimpleDateFormat(format);
    }

    /**
     * 对日期的【秒】进行加/减
     * @param date v日期
     * @param seconds  秒数，负数为减
     * @return 加/减几秒后的日期
     */
    public static Date addDateSeconds(Date date, int seconds) {
        DateTime dateTime = new DateTime(date);
        return dateTime.plusSeconds(seconds).toDate();
    }

    /**
     * 对日期的【分钟】进行加/减
     * @param date 日期
     * @param minutes 分钟数，负数为减
     * @return 加/减几分钟后的日期
     */
    public static Date addDateMinutes(Date date, int minutes) {
        DateTime dateTime = new DateTime(date);
        return dateTime.plusMinutes(minutes).toDate();
    }

    /**
     * 对日期的【小时】进行加/减
     * @param date 日期
     * @param hours 小时数，负数为减
     * @return 加/减几小时后的日期
     */
    public static Date addDateHours(Date date, int hours) {
        DateTime dateTime = new DateTime(date);
        return dateTime.plusHours(hours).toDate();
    }

    /**
     * 对日期的【天】进行加/减
     * @param date 日期
     * @param days 天数，负数为减
     * @return 加/减几天后的日期
     */
    public static Date addDateDays(Date date, int days) {
        DateTime dateTime = new DateTime(date);
        return dateTime.plusDays(days).toDate();
    }

    /**
     * 对日期的【周】进行加/减
     * @param date 日期
     * @param weeks 周数，负数为减
     * @return 加/减几周后的日期
     */
    public static Date addDateWeeks(Date date, int weeks) {
        DateTime dateTime = new DateTime(date);
        return dateTime.plusWeeks(weeks).toDate();
    }

    /**
     * 对日期的【月】进行加/减
     * @param date 日期
     * @param months 月数，负数为减
     * @return 加/减几月后的日期
     */
    public static Date addDateMonths(Date date, int months) {
        DateTime dateTime = new DateTime(date);
        return dateTime.plusMonths(months).toDate();
    }

    /**
     * 对日期的【年】进行加/减
     * @param date 日期
     * @param years 年数，负数为减
     * @return 加/减几年后的日期
     */
    public static Date addDateYears(Date date, int years) {
        DateTime dateTime = new DateTime(date);
        return dateTime.plusYears(years).toDate();
    }

    /**
     * 计算 minute 分钟后的时间
     * @param date 源数据
     * @param minute 分钟
     * @return 结果
     */
    public static Date addMinute(Date date, int minute) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MINUTE, minute);
        return calendar.getTime();
    }

    /**
     * 计算 seconds天 后的时间
     * @param tmpDate 数据源
     * @param seconds 天数
     * @return 结果
     */
    public static Date addDate(Date tmpDate, int seconds) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(tmpDate);
        calendar.add(Calendar.SECOND, seconds);
        return calendar.getTime();
    }

    /**
     * 增加日期中天数
     * @param s 数据源
     * @param n 天数
     * @return 结果
     */
    public static String addDay(Date s, int n) {
        SimpleDateFormat FORMATER_DATE_YMD = new SimpleDateFormat("yyyy-MM-dd");
        Calendar cd = Calendar.getInstance();
        cd.setTime(s);
        cd.add(Calendar.DATE, n);// 增加一天
        // cd.add(Calendar.MONTH, n);//增加一个月
        return FORMATER_DATE_YMD.format(cd.getTime());
    }

    /**
     * 增加日期中某类型的某数值。如增加日期
     * @param date     日期
     * @param dateType 类型
     * @param amount   数值
     * @return 计算后日期
     */
    private static Date addInteger(Date date, int dateType, int amount) {
        Date myDate = null;
        if (date != null) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(dateType, amount);
            myDate = calendar.getTime();
        }
        return myDate;
    }

    /**
     * 增加日期的年份。失败返回null。
     * @return 增加年份后的日期
     */
    public static Date addYear(Date date, int yearAmount) {
        return addInteger(date, Calendar.YEAR, yearAmount);
    }

    /**
     * 增加日期的月份。失败返回null。
     * @return 增加月份后的日期
     */
    public static Date addMonth(Date date, int yearAmount) {
        return addInteger(date, Calendar.MONTH, yearAmount);
    }

    /**
     * 增加日期的天数。失败返回null。
     * @return 增加天数后的日期
     */
    public static Date addsDay(Date date, int dayAmount) {
        return addInteger(date, Calendar.DATE, dayAmount);
    }

    /**
     * 增加日期的小时。失败返回null。
     * @return 增加小时后的日期
     */
    public static Date addHour(Date date, int hourAmount) {
        return addInteger(date, Calendar.HOUR_OF_DAY, hourAmount);
    }

    /**
     * 增加日期的分钟。失败返回null。
     * @return 增加分钟后的日期
     */
    public static Date addsMinute(Date date, int minAmount) {
        return addInteger(date, Calendar.MINUTE, minAmount);
    }

    /**
     * 增加日期的秒钟。失败返回null。
     * @return 增加秒钟后的日期
     */
    public static Date addsSecond(Date date, int secondAmount) {
        return addInteger(date, Calendar.SECOND, secondAmount);
    }

    /**
     * 得到指定日期当天的开始时间 （yyyy-MM-01 00:00:00.000）
     * @param date 数据源
     * @return 结果
     */
    public static Date getStartOfMonth(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 得到指定日期当天的结束时间 （yyyy-MM-dd 23:59:59.0）
     * @param date 数据源
     * @return 结果
     */
    public static Date getEndDateTimeOfMonth(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MONTH, 1);
        calendar.set(Calendar.DAY_OF_MONTH,0);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 获取当前日期 毫秒
     * @return 结果
     */
    public static long getTimeInMillis(){
        Calendar now = Calendar.getInstance();
        return now.getTimeInMillis();
    }

    /**
     * 获取当前日期 秒
     * @return 结果
     */
    public static long getTimeInSeconds(){
        return getTimeInMillis()/1000L;
    }


    /**
     * 按日加
     * @param value 指定天数
     * @return 结果
     */
    public static Date addDay(int value) {
        Calendar now = Calendar.getInstance();
        now.add(Calendar.DAY_OF_YEAR, value);//按日加
        //now.add(Calendar.MONTH, value);// 按月加
        //now.add(Calendar.YEAR, value);//按年加
        //now.add(Calendar.HOUR_OF_DAY, value);//按小时加
        //now.add(Calendar.MINUTE, value);//按分钟加
        return now.getTime();
    }

    /**
     * 按日加,指定日期
     * @param date 数据源
     * @param value 天数
     * @return 结果
     */
    public static Date addDay2(Date date, int value) {
        Calendar now = Calendar.getInstance();
        now.setTime(date);
        now.add(Calendar.DAY_OF_YEAR, value);//按日加,指定日期
        //now.add(Calendar.MONTH, value);//按月加,指定日期
        //now.add(Calendar.YEAR, value);//按年加,指定日期
        //now.add(Calendar.HOUR_OF_DAY, value);//按小时加,指定日期
        //now.add(Calendar.MINUTE, value);//按分钟加,指定日期
        return now.getTime();
    }


    /** 时间格式(yyyy-MM-dd) */
    public final static String DATE_PATTERN = "yyyy-MM-dd";
    /** 时间格式(yyyy-MM-dd HH:mm:ss) */
    public final static String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

    /**
     * 日期格式化 日期格式为：yyyy-MM-dd
     * @param date  日期
     * @return  返回yyyy-MM-dd格式日期
     */
    public static String format(Date date) {
        return format(date, DATE_PATTERN);
    }

    /**
     * 日期格式化 日期格式为：yyyy-MM-dd
     * @param date  日期
     * @param pattern  格式，如：DateUtils.DATE_TIME_PATTERN
     * @return  返回yyyy-MM-dd格式日期
     */
    public static String format(Date date, String pattern) {
        if(date != null){
            SimpleDateFormat df = new SimpleDateFormat(pattern);
            return df.format(date);
        }
        return null;
    }

    /**
     * 字符串转换成日期
     * @param strDate 日期字符串
     * @param pattern 日期的格式，如：DateUtils.DATE_TIME_PATTERN
     */
    public static Date stringToDate(String strDate, String pattern) {
        if (StringUtil.isBlank(strDate)){
            return null;
        }

        DateTimeFormatter fmt = DateTimeFormat.forPattern(pattern);
        return fmt.parseLocalDateTime(strDate).toDate();
    }

    /**
     * 根据周数，获取开始日期、结束日期
     * @param week  周期  0本周，-1上周，-2上上周，1下周，2下下周
     * @return  返回date[0]开始日期、date[1]结束日期
     */
    public static Date[] getWeekStartAndEnd(int week) {
        DateTime dateTime = new DateTime();
        LocalDate date = new LocalDate(dateTime.plusWeeks(week));

        date = date.dayOfWeek().withMinimumValue();
        Date beginDate = date.toDate();
        Date endDate = date.plusDays(6).toDate();
        return new Date[]{beginDate, endDate};
    }



    /**
     * @param date 字符型时间格式
     * @param  format 格式
     * @return  结果
     * */
    public static Date strFormatDate(String date, String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        try {
            return sdf.parse(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 时间字符串格式化
     * @param dateStr 数据源
     * @param beforeFormat  输入格式
     * @param afterFormat  输出格式
     * @return 结果
     */
    public static String formatStrDate(String dateStr, String beforeFormat, String afterFormat) {
        try {
            if (dateStr.length() != beforeFormat.length()) {
                return dateStr;
            }
            SimpleDateFormat bdf = new SimpleDateFormat(beforeFormat);
            SimpleDateFormat adf = new SimpleDateFormat(afterFormat);
            if (null != dateStr) {
                return adf.format(bdf.parse(dateStr));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return dateStr;
    }

    /**
     * 获取当前时间的字符串（yyyyMMddHHmmss）
     * @return 结果
     */
    public static String getTimestampStr(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
        return sdf.format(new Date());
    }

    /**
     * 日切日期减1
     * @param dailySwthchDate 数据源
     * @return 结果
     */
    public static String convertDate(String dailySwthchDate) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar ordcal = Calendar.getInstance();
        String returnDate = null;
        try {
            Date orderDate = sdf.parse(dailySwthchDate);
            ordcal.setTime(orderDate);
        } catch (Exception e) {
            // 如果转化失败取当天时间
            ordcal.setTime(new Date());
        }finally{
            ordcal.add(Calendar.DATE, -1);
            returnDate = sdf.format(ordcal.getTime());
        }
        return returnDate;
    }


    /**
     * 日期减一
     * @param date 数据源
     * @param format 格式
     * @return 结果
     */
    public static Integer lastDate(Integer date, String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        try {
            Date orderDate = sdf.parse(String.valueOf(date));
            Calendar ordcal = Calendar.getInstance();
            ordcal.setTime(orderDate);
            ordcal.add(Calendar.DATE, -1);
            return Integer.valueOf(sdf.format(ordcal.getTime()));
        } catch (Exception e) {
            sdf = new SimpleDateFormat("yyyyMMdd");
            return Integer.valueOf(sdf.format(new Date()));
        }
    }

    /**
     * 日切日期加一减一天
     * @param dailySwthchDate 数据源
     * @return 结果
     */
    public static String compaterDailyDate(String dailySwthchDate,int dayDate) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = Calendar.getInstance();
        String returnDate = null;
        try {
            Date switchDate = sdf.parse(dailySwthchDate);
            calendar.setTime(switchDate);
        } catch (ParseException e) {
            // 如果转化失败取当天时间
            calendar.setTime(new Date());
        } finally {
            calendar.add(Calendar.DATE, dayDate);
            returnDate = sdf.format(calendar.getTime());
        }
        return returnDate;
    }



    public static String formatNextDate(String sDate,String format){
        if(StringUtils.isEmpty(sDate)){
            return "";
        }
        SimpleDateFormat df = new SimpleDateFormat(format);
        Calendar cal  = null;
        try {
            Date dDate = df.parse(sDate);
            cal = Calendar.getInstance();
            cal.setTime(dDate);
            cal.add(Calendar.DAY_OF_MONTH, 1);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return df.format(cal.getTime());
    }

    public static Date formatStr2Date(String sDate,String format){
        if(StringUtils.isEmpty(sDate)){
            return null;
        }
        SimpleDateFormat df = new SimpleDateFormat(format);
        Calendar cal  = null;
        try {
            Date dDate = df.parse(sDate);
            cal = Calendar.getInstance();
            cal.setTime(dDate);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return cal.getTime();
    }

    /**
     * 获取上一日日期（yyyy-MM-dd）
     * @return 结果
     */
    public static String getRoundDateString(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        calendar.add(Calendar.DAY_OF_MONTH, -1);
        Date date = calendar.getTime();
        return sdf.format(date);
    }

    public static String nextDate(String date, String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        try {
            Date orderDate = sdf.parse(date);
            Calendar ordcal = Calendar.getInstance();
            ordcal.setTime(orderDate);
            ordcal.add(Calendar.DATE, 1);
            return sdf.format(ordcal.getTime());
        } catch (Exception e) {
            return getTimestampStr();
        }
    }

    public static String expDate(String expDate){
        String date=null;
        try {
            if(!StringUtils.isEmpty(expDate)){
                SimpleDateFormat sdf = new SimpleDateFormat("yymm");
                Date dateStr=sdf.parse(expDate);
                sdf = new SimpleDateFormat("mmyy");
                date=sdf.format(dateStr);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return date;
    }

    public boolean computeIntervalTime(Integer intervalTime, Date finishTime) {
        if (finishTime == null || intervalTime == null || intervalTime <= 0) {
            return false;
        }
        Date currentDate = new Date();
        long nextTime  = currentDate.getTime() / 60000;
        long parentTime = finishTime.getTime() / 60000;
        return nextTime - parentTime < intervalTime;
    }

    /**
     * 计算毫秒数
     * @param  hour 小时
     * @param  minute 分钟
     * @return  结果
     */
    private static long timeMillis(int hour, int minute) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.HOUR_OF_DAY, hour);
        calendar.set(Calendar.MINUTE, minute);
        return calendar.getTimeInMillis();
    }


    /**
     * 判断当前时间是否在一定的时间范围内
     * @param startTime 开始时间
     * @param  endTime 结束时间
     * @return boolean
     */
    public static boolean isInBetweenTimes(String startTime, String endTime) {
        Date nowTime = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        String time = sdf.format(nowTime);
        if (time.compareTo(startTime) >= 0 && time.compareTo(endTime) <= 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 判断开始时间和结束时间，是否超出了当前时间的一定的间隔数限制, 时间单位默认为天数 如：开始时间和结束时间，不能超出距离当前时间90天
     * @param startDate 开始时间
     * @param endDate 结束时间按
     * @param interval 间隔数
     * @return 结果
     */
    public static boolean isOverIntervalLimit(Date startDate, Date endDate, int interval) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(new Date());
        cal.add(Calendar.DAY_OF_MONTH, interval * (-1));
        Date curDate = getDayStart(cal.getTime());
        if (getDayStart(startDate).compareTo(curDate) < 0 || getDayStart(endDate).compareTo(curDate) < 0) {
            return true;
        }
        return false;
    }

    /**
     * 得到day的起始时间点。
     * @param date 数据源
     * @return 结果
     */
    public static Date getDayStart(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 得到day的终止时间点.
     * @param date 数据源
     * @return 结果
     */
    public static Date getDayEnd(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        calendar.add(Calendar.DAY_OF_MONTH, 1);
        calendar.add(Calendar.MILLISECOND, -1);
        return calendar.getTime();
    }

    /**
     * 计算 second 秒后的时间
     * @param date 数据源
     * @param second 秒
     * @return  结果
     */
    public static Date addSecond(Date date, int second) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        ;
        calendar.add(Calendar.SECOND, second);
        return calendar.getTime();
    }







    /**
     * 字符转日期
     * @param dateStr 数据源
     * @return 结果
     */
    public static Date getDateByStr(String dateStr) {
        SimpleDateFormat formatter = null;
        if (dateStr == null) {
            return null;
        } else if (dateStr.length() == 10) {
            formatter = new SimpleDateFormat("yyyy-MM-dd");
        } else if (dateStr.length() == 16) {
            formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        } else if (dateStr.length() == 19) {
            formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        } else if (dateStr.length() > 19) {
            dateStr = dateStr.substring(0, 19);
            formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        } else {
            return null;
        }
        try {
            return formatter.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 是否为时间格式：hh:mm:ss
     * @param timeStr 数据源
     * @return 结果
     */
    public static boolean isTime(String timeStr) {
        SimpleDateFormat df = new SimpleDateFormat("hh:mm:ss");
        Date date = null;
        try {
            date = df.parse(timeStr);
        } catch (ParseException e) {
            return false;
        }
        return date != null;
    }

    /**
     * 是否为日期时间格式：yyyy-MM-dd hh:mm:ss or yyyy-MM-dd hh:mm
     * @param dateTime 数据源
     * @return 结果
     */
    public static boolean isDateTime(String dateTime) {
        int first = dateTime.indexOf(":");
        int last = dateTime.lastIndexOf(":");
        if (first == -1) {
            return false;
        }
        SimpleDateFormat df = null;
        if (first == last) {
            df = new SimpleDateFormat("yyyy-MM-dd hh:mm");
        } else {
            df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        }
        Date date = null;
        try {
            date = df.parse(dateTime);
        } catch (ParseException e) {
            return false;
        }
        return date == null;
    }


    /**
     * 时间比较
     * @param date1 时间1
     * @param date2 时间2
     * @return DATE1>DATE2返回1，DATE1<DATE2返回-1,等于返回0
     */
    public static int compareDate(String date1, String date2, String format) {
        DateFormat df = new SimpleDateFormat(format);
        try {
            Date dt1 = df.parse(date1);
            Date dt2 = df.parse(date2);
            if (dt1.getTime() > dt2.getTime()) {
                return 1;
            } else if (dt1.getTime() < dt2.getTime()) {
                return -1;
            } else {
                return 0;
            }
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return 0;
    }



    /**
     * 给时间加上几个小时
     * @param day  当前时间 格式：yyyy-MM-dd HH:mm:ss
     * @param hour 需要加的时间
     * @return 结果
     */
    public static String addDateHour(String day, int hour) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = null;
        try {
            date = format.parse(day);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        if (date == null)
            return "";
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.HOUR, hour);// 24小时制
        date = cal.getTime();
        cal = null;
        return format.format(date);
    }

    /**
     * 获取指定分钟之前的时间
     * @param minute 指定分钟
     * @return 指定分钟之前格式化后的时间 yyyy-MM-dd HH:MM
     * 保留，先，admin中
     */
    public static String getDateOfSpecifyMinuteBeFore(Long minute) {
        LocalDateTime today = LocalDateTime.now();
        LocalDateTime after = today.minus(minute, ChronoUnit.MINUTES);
        return java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm").format(after);
    }

    public static String compareDate(String date1, String date2) {
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm");
        try {
            Date dt1 = df.parse(date1);
            Date dt2 = df.parse(date2);
            if (dt1.getTime() > dt2.getTime()) {
                return date1;
            } else if (dt1.getTime() < dt2.getTime()) {
                return date2;
            } else {
                return date1;
            }
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return date1;
    }

    /**
     * 获取两个时间相差分钟数
     * @param start 开始时间
     * @param end 结束时间
     * @return 分钟数
     */
    public static int getTimeDifference(String start,String end){
        //把当前时间和要比较的时间转换为Date类型，目的在于得到这两个时间的毫秒值
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
        Date parse = null;
        Date now = null;
        try {
            parse = sdf.parse(start);
            now = sdf.parse(end);
        } catch (ParseException e) {
        }
        //获得这两个时间的毫秒值后进行处理(因为我的需求不需要处理时间大小，所以此处没有处理，可以判断一下哪个大就用哪个作为减数。)
        long diff = now.getTime() - parse.getTime();
        //此处用毫秒值除以分钟再除以毫秒既得两个时间相差的分钟数
        long minute = diff/60/1000;
        return (int)minute;
    }


    public static String simpleDatetime(String datetime) {
        if (datetime == null) {
            return "";
        }
        if (datetime.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")) {
            return datetime.substring(5, 16);
        } else if (datetime.matches("\\d{4}-\\d{2}-\\d{2}")) {
            return datetime.substring(5, 10);
        } else if (datetime.matches("\\d{2}:\\d{2}:\\d{2}")) {
            return datetime.substring(0, 5);
        }
        return datetime;
    }

    // 判断是否在可用时间内
    public static long DEFAULT_TIMEOUT_SECOND = 70 * 60 * 1000;
    public static boolean isUsable(Date date) {
        if (null == date) {
            return false;
        }
        if (new Date().getTime() - date.getTime() > DEFAULT_TIMEOUT_SECOND) {
            return false;
        }
        return true;
    }

    /**
     * 获取前一天0点时间
     * @param date 源数据
     * @return 结构
     */
    public static Date getStartOfYesterday(Date date) {
        long zero = System.currentTimeMillis() / (1000 * 3600 * 24) * (1000 * 3600 * 24) - TimeZone.getDefault().getRawOffset();
        zero = zero - 1000 * 3600 * 24;
        return new Date(zero);
    }

    /**
     * 获取前一天23:59
     * @param date 源数据
     * @return 结果
     */
    public static Date getEndOfYesterday(Date date) {
        long zero = getStartOfYesterday(new Date()).getTime();
        return new Date(zero + 1000 * 3600 * 24 - 1);
    }




    private static final String[] weeks = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};

    /**
     * 获得某日期的月份的总天数
     * @param dateString "2018-01-30"
     * @return  结果2
     */
    public static int getDaysOfMonth(String dateString){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = sdf.parse(dateString);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
    }


    /**
     * 比较两个日期的大小。<br>
     * 若date1 > date2 则返回 1<br>
     * 若date1 = date2 则返回 0<br>
     * 若date1 < date2 则返回-1
     * @param date1 日期1
     * @param date2 日期2
     * @param format  待转换的格式
     * @return 比较结果
     */
    public static int compare(String date1, String date2,String format) {
        DateFormat df = getFormat(format);
        try {
            Date dt1 = df.parse(date1);
            Date dt2 = df.parse(date2);
            if (dt1.getTime() > dt2.getTime()) {
                return 1;
            } else if (dt1.getTime() < dt2.getTime()) {
                return -1;
            } else {
                return 0;
            }
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return 0;
    }

    /**
     * 对 "yyyy-MM-dd" 格式的日期数组进行排序（插入排序）
     * @param a 数据源
     * @return 结果
     */
    public static String[] dateSort(String[] a) {
        String temp;
        int j;
        for (int i = 1; i < a.length; i++) {
            temp = a[i];
            for (j = i; j > 0 && compare(temp, a[j - 1], "yyyy-MM-dd") == -1; j--) {
                a[j] = a[j - 1];
            }
            a[j] = temp;
        }
        return a;
    }

    /**
     * 根据指定格式获取当前时间
     * @param format
     * @return String
     */
    public static String getCurrentTime(String format){
        SimpleDateFormat sdf = getFormat(format);
        Date date = new Date();
        return sdf.format(date);
    }

    /**
     * 获取当前时间，格式为：yyyy-MM-dd HH:mm:ss
     * @return String
     */
    public static String getCurrentTime(){
        return getCurrentTime(DATE_FORMAT2);
    }

    /**
     * 获取指定格式的当前时间：为空时格式为yyyy-mm-dd HH:mm:ss
     * @param format 格式
     * @return Date
     */
    public static Date getCurrentDate(String format){
        SimpleDateFormat sdf = getFormat(format);
        String dateS = getCurrentTime(format);
        Date date = null;
        try {
            date = sdf.parse(dateS);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 获取当前时间，格式为yyyy-MM-dd HH:mm:ss
     * @return Date
     */
    public static Date getCurrentDate(){
        return getCurrentDate(DATE_FORMAT2);
    }

    /**
     * 给指定日期加入年份，为空时默认当前时间
     * @param year 年份  正数相加、负数相减
     * @param date 为空时，默认为当前时间
     * @param format 默认格式为：yyyy-MM-dd HH:mm:ss
     * @return String
     */
    public static String addYearToDate(int year,Date date,String format){
        Calendar calender = getCalendar(date,format);
        SimpleDateFormat sdf = getFormat(format);

        calender.add(Calendar.YEAR, year);

        return sdf.format(calender.getTime());
    }

    /**
     * 给指定日期加入年份，为空时默认当前时间
     * @param year 年份  正数相加、负数相减
     * @param date 为空时，默认为当前时间
     * @param format 默认格式为：yyyy-MM-dd HH:mm:ss
     * @return String
     */
    public static String addYearToDate(int year,String date,String format){
        Date newDate = new Date();
        if(null != date && !"".equals(date)){
            newDate = string2Date(date, format);
        }

        return addYearToDate(year, newDate, format);
    }

    /**
     * 给指定日期增加月份 为空时默认当前时间
     * @param month  增加月份  正数相加、负数相减
     * @param date 指定时间
     * @param format 指定格式 为空默认 yyyy-mm-dd HH:mm:ss
     * @return String
     */
    public static String addMothToDate(int month,Date date,String format) {
        Calendar calender = getCalendar(date,format);
        SimpleDateFormat sdf = getFormat(format);

        calender.add(Calendar.MONTH, month);

        return sdf.format(calender.getTime());
    }

    /**
     * 给指定日期增加月份 为空时默认当前时间
     * @param month  增加月份  正数相加、负数相减
     * @param date 指定时间
     * @param format 指定格式 为空默认 yyyy-mm-dd HH:mm:ss
     * @return String
     */
    public static String addMothToDate(int month,String date,String format) {
        Date newDate = new Date();
        if(null != date && !"".equals(date)){
            newDate = string2Date(date, format);
        }

        return addMothToDate(month, newDate, format);
    }

    /**
     * 给指定日期增加天数，为空时默认当前时间
     * @param day 增加天数 正数相加、负数相减
     * @param date 指定日期
     * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
     * @return String
     */
    public static String addDayToDate(int day,Date date,String format) {
        Calendar calendar = getCalendar(date, format);
        SimpleDateFormat sdf = getFormat(format);

        calendar.add(Calendar.DATE, day);

        return sdf.format(calendar.getTime());
    }

    /**
     * 给指定日期增加天数，为空时默认当前时间
     * @param day 增加天数 正数相加、负数相减
     * @param date 指定日期
     * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
     * @return String
     */
    public static String addDayToDate(int day,String date,String format) {
        Date newDate = new Date();
        if(null != date && !"".equals(date)){
            newDate = string2Date(date, format);
        }

        return addDayToDate(day, newDate, format);
    }

    /**
     * 给指定日期增加小时，为空时默认当前时间
     * @param hour 增加小时  正数相加、负数相减
     * @param date 指定日期
     * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
     * @return String
     */
    public static String addHourToDate(int hour,Date date,String format) {
        Calendar calendar = getCalendar(date, format);
        SimpleDateFormat sdf = getFormat(format);

        calendar.add(Calendar.HOUR, hour);

        return sdf.format(calendar.getTime());
    }

    /**
     * 给指定日期增加小时，为空时默认当前时间
     * @param hour 增加小时  正数相加、负数相减
     * @param date 指定日期
     * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
     * @return String
     */
    public static String addHourToDate(int hour,String date,String format) {
        Date newDate = new Date();
        if(null != date && !"".equals(date)){
            newDate = string2Date(date, format);
        }

        return addHourToDate(hour, newDate, format);
    }

    /**
     * 给指定的日期增加分钟，为空时默认当前时间
     * @param minute 增加分钟  正数相加、负数相减
     * @param date 指定日期
     * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
     * @return String
     */
    public static String addMinuteToDate(int minute,Date date,String format) {
        Calendar calendar = getCalendar(date, format);
        SimpleDateFormat sdf = getFormat(format);

        calendar.add(Calendar.MINUTE, minute);

        return sdf.format(calendar.getTime());
    }

    /**
     * 给指定的日期增加分钟，为空时默认当前时间
     * @param minute 增加分钟  正数相加、负数相减
     * @param date 指定日期
     * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
     * @return String
     */
    public static String addMinuteToDate(int minute,String date,String format){
        Date newDate = new Date();
        if(null != date && !"".equals(date)){
            newDate = string2Date(date, format);
        }

        return addMinuteToDate(minute, newDate, format);
    }

    /**
     * 给指定日期增加秒，为空时默认当前时间
     * @param second 增加秒 正数相加、负数相减
     * @param date 指定日期
     * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
     * @return String
     */
    public static String addSecondToDate(int second,Date date,String format){
        Calendar calendar = getCalendar(date, format);
        SimpleDateFormat sdf = getFormat(format);

        calendar.add(Calendar.SECOND, second);

        return sdf.format(calendar.getTime());
    }

    /**
     * 给指定日期增加秒，为空时默认当前时间
     * @param second 增加秒 正数相加、负数相减
     * @param date 指定日期
     * @param format 日期格式 为空默认 yyyy-mm-dd HH:mm:ss
     * @return String
     */
    public static String addSecondToDate(int second,String date,String format){
        Date newDate = new Date();
        if(null != date && !"".equals(date)){
            newDate = string2Date(date, format);
        }

        return addSecondToDate(second, newDate, format);
    }

    /**
     * 获取指定格式指定时间的日历
     * @param date 时间
     * @param format 格式
     * @return Calendar
     */
    public static Calendar getCalendar(Date date,String format){
        if(date == null){
            date = getCurrentDate(format);
        }

        Calendar calender = Calendar.getInstance();
        calender.setTime(date);

        return calender;
    }

    /**
     * 字符串转换为日期，日期格式为
     * @param value 数据源
     * @return 结果
     */
    public static Date string2Date(String value){
        if(value == null || "".equals(value)){
            return null;
        }

        SimpleDateFormat sdf = getFormat(DATE_FORMAT2);
        Date date = null;

        try {
            value = formatDate(value, DATE_FORMAT2);
            date = sdf.parse(value);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 将字符串(格式符合规范)转换成Date
     * @param value 需要转换的字符串
     * @param format 日期格式
     * @return Date
     */
    public static Date string2Date(String value,String format){
        if(value == null || "".equals(value)){
            return null;
        }

        SimpleDateFormat sdf = getFormat(format);
        Date date = null;

        try {
            value = formatDate(value, format);
            date = sdf.parse(value);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 将日期格式转换成String
     * @param value 需要转换的日期
     * @param format 日期格式
     * @return String
     */
    public static String date2String(Date value,String format){
        if(value == null){
            return null;
        }

        SimpleDateFormat sdf = getFormat(format);
        return sdf.format(value);
    }

    /**
     * 日期转换为字符串
     * @param value  数据源
     * @return 结果
     */
    public static String date2String(Date value){
        if(value == null){
            return null;
        }

        SimpleDateFormat sdf = getFormat(DATE_FORMAT2);
        return sdf.format(value);
    }

    /**
     * 获取指定日期的年份
     * @param value 日期
     * @return int
     */
    public static int getCurrentYear(Date value){
        String date = date2String(value, DATE_YEAR);
        return Integer.valueOf(date);
    }

    /**
     * 获取指定日期的年份
     * @param value 日期
     * @return int
     */
    public static int getCurrentYear(String value) {
        Date date = string2Date(value, DATE_YEAR);
        Calendar calendar = getCalendar(date, DATE_YEAR);
        return calendar.get(Calendar.YEAR);
    }

    /**
     * 获取指定日期的月份
     * @param value 日期
     * @return int
     */
    public static int getCurrentMonth(Date value){
        String date = date2String(value, DATE_MONTH);
        return Integer.valueOf(date);
    }

    /**
     * 获取指定日期的月份 yyyy-MM-dd 格式
     * @param value 日期
     * @return int
     */
    public static int getCurrentMonth(String value) {
        Date date = string2Date(value, DATE_FORMAT1);
        Calendar calendar = getCalendar(date, DATE_FORMAT1);
        return calendar.get(Calendar.MONTH) + 1;
    }

    /**
     * 获取指定日期的天份
     * @param value 日期
     * @return int
     */
    public static int getCurrentDay(Date value){
        String date = date2String(value, DATE_DAY);
        return Integer.valueOf(date);
    }

    /**
     * 获取指定日期的天份
     * @param value 日期
     * @return int
     */
    public static int getCurrentDay(String value){
        Date date = string2Date(value, DATE_DAY);
        Calendar calendar = getCalendar(date, DATE_DAY);

        return calendar.get(Calendar.DATE);
    }

    /**
     * 获取当前日期为星期几
     * @param value 日期
     * @return String
     */
    public static String getCurrentWeek(Date value) {
        Calendar calendar = getCalendar(value, DATE_FORMAT1);
        int weekIndex = calendar.get(Calendar.DAY_OF_WEEK) - 1 < 0 ? 0 : calendar.get(Calendar.DAY_OF_WEEK) - 1;

        return weeks[weekIndex];
    }

    /**
     * 获取当前日期为星期几
     * @author chenssy
     * @date Dec 31, 2013
     * @param value 日期
     * @return String
     */
    public static String getCurrentWeek(String value) {
        Date date = string2Date(value, DATE_FORMAT1);
        return getCurrentWeek(date);
    }

    /**
     * 获取指定日期的小时
     * @param value 日期
     * @return int
     */
    public static int getCurrentHour(Date value){
        String date = date2String(value, DATE_HOUR);
        return Integer.valueOf(date);
    }

    /**
     * 获取指定日期的小时
     * @param value 日期
     * @return 结果
     */
    public static int getCurrentHour(String value) {
        Date date = string2Date(value, DATE_HOUR);
        Calendar calendar = getCalendar(date, DATE_HOUR);

        return calendar.get(Calendar.DATE);
    }

    /**
     * 获取指定日期的分钟
     * @param value 日期
     * @return int
     */
    public static int getCurrentMinute(Date value){
        String date = date2String(value, DATE_MINUTE);
        return Integer.valueOf(date);
    }

    /**
     * 获取指定日期的分钟
     * @param value 日期
     * @return int
     */
    public static int getCurrentMinute(String value){
        Date date = string2Date(value, DATE_MINUTE);
        Calendar calendar = getCalendar(date, DATE_MINUTE);

        return calendar.get(Calendar.MINUTE);
    }

    /**
     * 比较两个日期相隔多少天(月、年) <br>
     * 例：<br>
     * &nbsp;compareDate("2009-09-12", null, 0);//比较天 <br>
     * &nbsp;compareDate("2009-09-12", null, 1);//比较月 <br>
     * &nbsp;compareDate("2009-09-12", null, 2);//比较年 <br>
     *
     * @param startDay 需要比较的时间 不能为空(null),需要正确的日期格式 ,如：2009-09-12
     * @param endDay 被比较的时间  为空(null)则为当前时间
     * @param stype 返回值类型   0为多少天，1为多少个月，2为多少年
     * @return int
     */
    public static int compareDate(String startDay,String endDay,int stype) {
        int n = 0;
        startDay = formatDate(startDay, "yyyy-MM-dd");
        endDay = formatDate(endDay, "yyyy-MM-dd");

        String formatStyle = "yyyy-MM-dd";
        if(1 == stype){
            formatStyle = "yyyy-MM";
        }else if(2 == stype){
            formatStyle = "yyyy";
        }

        endDay = endDay==null ? getCurrentTime("yyyy-MM-dd") : endDay;

        DateFormat df = new SimpleDateFormat(formatStyle);
        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();
        try {
            c1.setTime(df.parse(startDay));
            c2.setTime(df.parse(endDay));
        } catch (Exception e) {
            e.printStackTrace();
        }
        while (!c1.after(c2)) {                   // 循环对比，直到相等，n 就是所要的结果
            n++;
            if(stype==1){
                c1.add(Calendar.MONTH, 1);          // 比较月份，月份+1
            }
            else{
                c1.add(Calendar.DATE, 1);           // 比较天数，日期+1
            }
        }
        n = n-1;
        if(stype==2){
            n = (int)n/365;
        }
        return n;
    }

    /**
     * 比较两个时间相差多少小时(分钟、秒)
     * @param startTime 需要比较的时间 不能为空，且必须符合正确格式：2012-12-12 12:12:
     * @param endTime 需要被比较的时间 若为空则默认当前时间
     * @param type 1：小时   2：分钟   3：秒
     * @return int
     */
    public static int compareTime(String startTime , String endTime , int type) {
        //endTime是否为空，为空默认当前时间
        if(endTime == null || "".equals(endTime)){
            endTime = getCurrentTime();
        }

        SimpleDateFormat sdf = getFormat("");
        int value = 0;
        try {
            Date begin = sdf.parse(startTime);
            Date end = sdf.parse(endTime);
            long between = (end.getTime() - begin.getTime()) / 1000;  //除以1000转换成豪秒
            if(type == 1){   //小时
                value = (int) (between % (24 * 36000) / 3600);
            }
            else if(type == 2){
                value = (int) (between % 3600 / 60);
            }
            else if(type == 3){
                value = (int) (between % 60 / 60);
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return value;
    }

    /**
     * 获取指定月份的第一天
     * @param date 数据源
     * @return 结果
     */
    public static String getMonthFirstDate(String date){
        date = formatDate(date);
        return formatDate(date, "yyyy-MM") + "-01";
    }

    /**
     * 获取指定月份的最后一天
     * @param date 数据源
     * @return 结果
     */
    public static String getMonthLastDate(String date) {
        Date strDate = DateUtil.string2Date(getMonthFirstDate(date));
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(strDate);
        calendar.add(Calendar.MONTH, 1);
        calendar.add(Calendar.DAY_OF_YEAR, -1);
        return DateUtil.formatDate(calendar.getTime());
    }

    /**
     * 获取所在星期的第一天
     * @param date 数据源
     * @return 结果
     */
    @SuppressWarnings("static-access")
    public static Date getWeekFirstDate(Date date) {
        Calendar now = Calendar.getInstance();
        now.setTime(date);
        int today = now.get(Calendar.DAY_OF_WEEK);
        int first_day_of_week = now.get(Calendar.DATE) + 2 - today; // 星期一
        now.set(Calendar.DATE, first_day_of_week);
        return now.getTime();
    }

    /**
     * 获取所在星期的最后一天
     * @param date 数据源
     * @return 结果
     */
    @SuppressWarnings("static-access")
    public static Date geWeektLastDate(Date date) {
        Calendar now = Calendar.getInstance();
        now.setTime(date);
        int today = now.get(Calendar.DAY_OF_WEEK);
        int first_day_of_week = now.get(Calendar.DATE) + 2 - today; // 星期一
        int last_day_of_week = first_day_of_week + 6; // 星期日
        now.set(Calendar.DATE, last_day_of_week);
        return now.getTime();
    }


    /**
     * String转换为TimeStamp
     * @param value 待转换的String，格式必须为 yyyy-mm-dd hh:mm:ss[.f...] 这样的格式，中括号表示可选，否则报错
     * @return java.sql.Timestamp
     */
    public static Timestamp string2Timestamp(String value){
        if(value == null && !"".equals(value.trim())){
            return null;
        }
        Timestamp ts = new Timestamp(System.currentTimeMillis());
        ts = Timestamp.valueOf(value);
        return ts;
    }

    /**
     * 将Timestamp 转换为String类型，format为null则使用默认格式 yyyy-MM-dd HH:mm:ss
     * @param value 转换的Timestamp
     * @param format  String的格式
     * @return java.lang.String
     */
    public static String timestamp2String(Timestamp value,String format){
        if(null == value){
            return "";
        }
        SimpleDateFormat sdf = getFormat(format);

        return sdf.format(value);
    }

    /**
     * Date转换为Timestamp
     * @param date 待转换的Date
     * @return java.sql.Timestamp
     *
     */
    public static Timestamp date2Timestamp(Date date){
        if(date == null){
            return null;
        }
        return new Timestamp(date.getTime());
    }

    /**
     * Timestamp转换为Date
     * @param time 待转换的Timestamp
     * @return java.util.Date
     */
    public static Date timestamp2Date(Timestamp time){
        return time == null ? null : time;
    }

}
